/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.jili.ubert.clientapi;

import com.jili.ubert.clientapi.until.TransferData;
import com.jili.ubert.clientapi.until.AnswerHandler;
import com.jili.ubert.clientapi.until.AnswerMsgResult;
import com.jili.ubert.clientapi.until.AbstractWorker;
import com.jili.ubert.clientapi.until.DataOperate;
import com.jili.ubert.clientapi.until.TableName;
import com.jili.ubert.clientapi.until.UnWorkException;
import com.jili.ubert.code.client2server.RequestBatchOperateDB;
import com.jili.ubert.code.client2server.RequestOperateDBProto;
import com.jili.ubert.code.client2server.RequestPageData;
import com.jili.ubert.code.server2client.MsgResult;
import com.jili.ubert.code.server2client.PageDataProto;
import com.jili.ubert.code.server2client.SystemMessage;
import com.jili.ubert.dao.db.AccountBail;
import com.jili.ubert.dao.db.AccountFare;
import com.jili.ubert.dao.db.AccountIcode;
import com.jili.ubert.dao.db.AccountInfo;
import com.jili.ubert.dao.db.AccountInvest;
import com.jili.ubert.dao.db.AlterOrder;
import com.jili.ubert.dao.db.BailTemp;
import com.jili.ubert.dao.db.BailTempObj;
import com.jili.ubert.dao.db.CancelOrder;
import com.jili.ubert.dao.db.ClearingCurrencyRates;
import com.jili.ubert.dao.db.ClearingDayBook;
import com.jili.ubert.dao.db.ClearingExRight;
import com.jili.ubert.dao.db.ClearingPrice;
import com.jili.ubert.dao.db.ClearingProtfoliopos;
import com.jili.ubert.dao.db.FareTemp;
import com.jili.ubert.dao.db.FareTempeObj;
import com.jili.ubert.dao.db.FundState;
import com.jili.ubert.dao.db.FundTransfer;
import com.jili.ubert.dao.db.IOPVAccount;
import com.jili.ubert.dao.db.IOPVProduct;
import com.jili.ubert.dao.db.IOPVProductUnit;
import com.jili.ubert.dao.db.LogLoginInfo;
import com.jili.ubert.dao.db.NewOrder;
import com.jili.ubert.dao.db.ObjClassCode;
import com.jili.ubert.dao.db.ObjClassCodeAtrr;
import com.jili.ubert.dao.db.ObjETF;
import com.jili.ubert.dao.db.ObjETFList;
import com.jili.ubert.dao.db.ObjExRightInfo;
import com.jili.ubert.dao.db.ObjIndex;
import com.jili.ubert.dao.db.ObjIndexList;
import com.jili.ubert.dao.db.ObjInfo;
import com.jili.ubert.dao.db.ObjNewStock;
import com.jili.ubert.dao.db.ObjPriceTick;
import com.jili.ubert.dao.db.ObjProtfolio;
import com.jili.ubert.dao.db.ObjProtfolioList;
import com.jili.ubert.dao.db.ObjStructuredFundBase;
import com.jili.ubert.dao.db.ObjStructuredFundPart;
import com.jili.ubert.dao.db.ObjUnderlyingCode;
import com.jili.ubert.dao.db.OrderExecuteProgress;
import com.jili.ubert.dao.db.PosDetail;
import com.jili.ubert.dao.db.ProductAccount;
import com.jili.ubert.dao.db.ProductInfo;
import com.jili.ubert.dao.db.ProductUnit;
import com.jili.ubert.dao.db.RiskCtrlAssets;
import com.jili.ubert.dao.db.RiskIndex;
import com.jili.ubert.dao.db.RiskSets;
import com.jili.ubert.dao.db.SafeForbidLogin;
import com.jili.ubert.dao.db.SafeOtherAccess;
import com.jili.ubert.dao.db.TradeReportDetail;
import com.jili.ubert.dao.db.TradeSimOrderQuene;
import com.jili.ubert.dao.db.TradesetBroker;
import com.jili.ubert.dao.db.TradesetCalendar;
import com.jili.ubert.dao.db.TradesetExchangeLimit;
import com.jili.ubert.dao.db.TradesetPip;
import com.jili.ubert.dao.db.UserAccess;
import com.jili.ubert.dao.db.UserAccount;
import com.jili.ubert.dao.db.UserInfo;
import com.jili.ubert.dao.db.UserPrivateInfo;
import com.jili.ubert.dao.db.WorkFlowPath;
import com.jili.ubert.dao.db.WorkGroup;
import com.jili.ubert.dao.db.WorkGroupUser;
import com.jili.ubert.dao.db.WorkProductFlow;
import com.panemu.tiwulfx.common.TableCriteria;
import com.panemu.tiwulfx.common.TableData;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;
import javafx.scene.control.TableColumn;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 *
 * @author dragon
 */
public class TradeRequest {
    /*
     成员变量区
     */

    private final SessionBucket sessionBucket = new SessionBucket();
    private final ListenFundStateBucket listenFundStateBucket = new ListenFundStateBucket(16);
    private final ListenOrderExecuteProgressBucket listenOrderExecuteProgressBucket = new ListenOrderExecuteProgressBucket();
    private final ListenPOSBucket listenPOSBucket = new ListenPOSBucket(16);
    private final ListenSystemMessageBucket listenSystemMessageBucket = new ListenSystemMessageBucket(4);
    private final ListenCancelOrderBucket listenCancelOrderBucket = new ListenCancelOrderBucket(4);
    private final ListenAlterOrderBucket listenAlterOrderBucket = new ListenAlterOrderBucket(4);
    private final ListenNewOrderBucket listenNewOrderBucket = new ListenNewOrderBucket(4);
    private static final Log log = LogFactory.getLog(TradeRequest.class);
    private TradeNettyClient client;
    private DataPool dataPool;
    public void setDataPool(DataPool datapool) {
        this.dataPool = datapool;
    }
    public TradeRequest(){
        client = new TradeNettyClient();
    }
    public TradeRequest(String host, int port) {
        this.client = new TradeNettyClient();
        MsgResult ret = client.Connect(host, port, false, false, this);
        if (!ret.getSuccess()) {
            throw new UnWorkException(ret.getWord());
        }
    }

//    @Override
    public MsgResult Connect(ExecutorService exec, String host, int port, boolean isSSL, boolean isZlib) {
        log.info("正在登陆IP:" + host + "  Port:" + port);
        client.config(host, port, isSSL, isZlib, this);
        exec.execute(client);
        return client.getConnectRST();
        //    return tradeNettyClient.Connect(host, port, isSSL, isZlib, this);
    }

    private AtomicInteger requstid = new AtomicInteger(0);

    private int getRequstID() {
        if (requstid.getAndIncrement() == Integer.MAX_VALUE) {
            requstid.getAndSet(Integer.MIN_VALUE);
        }
        return requstid.intValue();
    }
    /*
     handler调用区
     */

    public void AccpetSessionAnswer(int id, MsgEntity msg) {
        this.sessionBucket.OnDealSession(id, msg);
    }

    public void AccpetSessionFaileAnswer(int id, MsgResult msg) {
        this.sessionBucket.OnFaile(id, msg);
    }

    public void OnPosDetail(PosDetail pos) {
        this.listenPOSBucket.OnDealListen(pos);
    }

    public void OnFundState(FundState fund) {
        this.listenFundStateBucket.OnDealListen(fund);
    }

    public void OnOrderExecuteProgress(OrderExecuteProgress orderexe) {
        this.listenOrderExecuteProgressBucket.OnDealListen(orderexe);
    }

    public void OnSystemMessage(SystemMessage msg) {
        this.listenSystemMessageBucket.OnDealListen(msg);
    }

    public void OnNewOrder(NewOrder msg) {
        this.listenNewOrderBucket.OnDealListen(msg);
    }

    public void OnCancelOrder(CancelOrder msg) {
        this.listenCancelOrderBucket.OnDealListen(msg);
    }

    public void OnAlterOrder(AlterOrder msg) {
        this.listenAlterOrderBucket.OnDealListen(msg);
    }
    public int operateDB(RequestOperateDBProto rdb,AnswerHandler<MsgResult> handler) throws IOException {
        int id = getRequstID();
        AbstractWorker worker = new AnswerMsgResult();
        worker.setAnswerHandler(handler);
        this.sessionBucket.AcceptSession(id, worker);
        client.SendSYNCMsg(626, getRequstID(), RequestOperateDBProto.EnCode(rdb));
        return id;
    }

    /*
     请求功能区
     */
    //其他功能处理
    private int operateDBlmp(int cmd,RequestOperateDBProto rdb,AnswerHandler<MsgResult> handler) throws IOException{
        int id = getRequstID();
        rdb.setInstructionID(id);
        AbstractWorker worker = new AnswerMsgResult();
        worker.setAnswerHandler(handler);
        this.sessionBucket.AcceptSession(id, worker);
        client.SendSYNCMsg(cmd, id, RequestOperateDBProto.EnCode(rdb));
        return id;
    }
    private int batchOperateDBlmp(int cmd,RequestBatchOperateDB rdb,AnswerHandler<MsgResult> handler) throws IOException{
        int id = getRequstID();
        rdb.setInstructionID(id);
        AbstractWorker worker = new AnswerMsgResult();
        worker.setAnswerHandler(handler);
        this.sessionBucket.AcceptSession(id, worker);
        client.SendSYNCMsg(cmd, id, RequestBatchOperateDB.EnCode(rdb));
        return id;
    }
    //单个操作
public int operateDB(int operate,AccountBail data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(AccountBail.EnCode(data));return operateDBlmp(627,rdb,handler);}
public int operateDB(int operate,AccountFare data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(AccountFare.EnCode(data));return operateDBlmp(628,rdb,handler);}
public int operateDB(int operate,AccountIcode data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(AccountIcode.EnCode(data));return operateDBlmp(629,rdb,handler);}
public int operateDB(int operate,AccountInfo data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(AccountInfo.EnCode(data));return operateDBlmp(630,rdb,handler);}
public int operateDB(int operate,AccountInvest data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(AccountInvest.EnCode(data));return operateDBlmp(631,rdb,handler);}
public int operateDB(int operate,AlterOrder data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(AlterOrder.EnCode(data));return operateDBlmp(632,rdb,handler);}
public int operateDB(int operate,BailTemp data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(BailTemp.EnCode(data));return operateDBlmp(633,rdb,handler);}
public int operateDB(int operate,BailTempObj data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(BailTempObj.EnCode(data));return operateDBlmp(634,rdb,handler);}
public int operateDB(int operate,CancelOrder data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(CancelOrder.EnCode(data));return operateDBlmp(635,rdb,handler);}
public int operateDB(int operate,ClearingCurrencyRates data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ClearingCurrencyRates.EnCode(data));return operateDBlmp(636,rdb,handler);}
public int operateDB(int operate,ClearingDayBook data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ClearingDayBook.EnCode(data));return operateDBlmp(637,rdb,handler);}
public int operateDB(int operate,ClearingExRight data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ClearingExRight.EnCode(data));return operateDBlmp(638,rdb,handler);}
public int operateDB(int operate,ClearingPrice data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ClearingPrice.EnCode(data));return operateDBlmp(639,rdb,handler);}
public int operateDB(int operate,ClearingProtfoliopos data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ClearingProtfoliopos.EnCode(data));return operateDBlmp(640,rdb,handler);}
public int operateDB(int operate,FareTemp data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(FareTemp.EnCode(data));return operateDBlmp(641,rdb,handler);}
public int operateDB(int operate,FareTempeObj data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(FareTempeObj.EnCode(data));return operateDBlmp(642,rdb,handler);}
public int operateDB(int operate,FundState data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(FundState.EnCode(data));return operateDBlmp(643,rdb,handler);}
public int operateDB(int operate,FundTransfer data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(FundTransfer.EnCode(data));return operateDBlmp(644,rdb,handler);}
public int operateDB(int operate,IOPVAccount data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(IOPVAccount.EnCode(data));return operateDBlmp(645,rdb,handler);}
public int operateDB(int operate,IOPVProduct data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(IOPVProduct.EnCode(data));return operateDBlmp(646,rdb,handler);}
public int operateDB(int operate,IOPVProductUnit data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(IOPVProductUnit.EnCode(data));return operateDBlmp(647,rdb,handler);}
public int operateDB(int operate,LogLoginInfo data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(LogLoginInfo.EnCode(data));return operateDBlmp(648,rdb,handler);}
public int operateDB(int operate,NewOrder data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(NewOrder.EnCode(data));return operateDBlmp(649,rdb,handler);}
public int operateDB(int operate,ObjClassCode data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjClassCode.EnCode(data));return operateDBlmp(650,rdb,handler);}
public int operateDB(int operate,ObjClassCodeAtrr data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjClassCodeAtrr.EnCode(data));return operateDBlmp(651,rdb,handler);}
public int operateDB(int operate,ObjETF data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjETF.EnCode(data));return operateDBlmp(652,rdb,handler);}
public int operateDB(int operate,ObjETFList data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjETFList.EnCode(data));return operateDBlmp(653,rdb,handler);}
public int operateDB(int operate,ObjExRightInfo data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjExRightInfo.EnCode(data));return operateDBlmp(654,rdb,handler);}
public int operateDB(int operate,ObjIndex data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjIndex.EnCode(data));return operateDBlmp(655,rdb,handler);}
public int operateDB(int operate,ObjIndexList data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjIndexList.EnCode(data));return operateDBlmp(656,rdb,handler);}
public int operateDB(int operate,ObjInfo data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjInfo.EnCode(data));return operateDBlmp(657,rdb,handler);}
public int operateDB(int operate,ObjNewStock data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjNewStock.EnCode(data));return operateDBlmp(658,rdb,handler);}
public int operateDB(int operate,ObjPriceTick data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjPriceTick.EnCode(data));return operateDBlmp(659,rdb,handler);}
public int operateDB(int operate,ObjProtfolio data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjProtfolio.EnCode(data));return operateDBlmp(660,rdb,handler);}
public int operateDB(int operate,ObjProtfolioList data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjProtfolioList.EnCode(data));return operateDBlmp(661,rdb,handler);}
public int operateDB(int operate,ObjStructuredFundBase data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjStructuredFundBase.EnCode(data));return operateDBlmp(662,rdb,handler);}
public int operateDB(int operate,ObjStructuredFundPart data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjStructuredFundPart.EnCode(data));return operateDBlmp(663,rdb,handler);}
public int operateDB(int operate,ObjUnderlyingCode data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ObjUnderlyingCode.EnCode(data));return operateDBlmp(664,rdb,handler);}
public int operateDB(int operate,OrderExecuteProgress data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(OrderExecuteProgress.EnCode(data));return operateDBlmp(665,rdb,handler);}
public int operateDB(int operate,PosDetail data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(PosDetail.EnCode(data));return operateDBlmp(666,rdb,handler);}
public int operateDB(int operate,ProductAccount data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ProductAccount.EnCode(data));return operateDBlmp(667,rdb,handler);}
public int operateDB(int operate,ProductInfo data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ProductInfo.EnCode(data));return operateDBlmp(668,rdb,handler);}
public int operateDB(int operate,ProductUnit data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(ProductUnit.EnCode(data));return operateDBlmp(669,rdb,handler);}
public int operateDB(int operate,RiskCtrlAssets data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(RiskCtrlAssets.EnCode(data));return operateDBlmp(670,rdb,handler);}
public int operateDB(int operate,RiskIndex data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(RiskIndex.EnCode(data));return operateDBlmp(671,rdb,handler);}
public int operateDB(int operate,RiskSets data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(RiskSets.EnCode(data));return operateDBlmp(672,rdb,handler);}
public int operateDB(int operate,SafeForbidLogin data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(SafeForbidLogin.EnCode(data));return operateDBlmp(673,rdb,handler);}
public int operateDB(int operate,SafeOtherAccess data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(SafeOtherAccess.EnCode(data));return operateDBlmp(674,rdb,handler);}
public int operateDB(int operate,TradeReportDetail data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(TradeReportDetail.EnCode(data));return operateDBlmp(675,rdb,handler);}
public int operateDB(int operate,TradesetBroker data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(TradesetBroker.EnCode(data));return operateDBlmp(676,rdb,handler);}
public int operateDB(int operate,TradesetCalendar data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(TradesetCalendar.EnCode(data));return operateDBlmp(677,rdb,handler);}
public int operateDB(int operate,TradesetExchangeLimit data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(TradesetExchangeLimit.EnCode(data));return operateDBlmp(678,rdb,handler);}
public int operateDB(int operate,TradesetPip data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(TradesetPip.EnCode(data));return operateDBlmp(679,rdb,handler);}
public int operateDB(int operate,TradeSimOrderQuene data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(TradeSimOrderQuene.EnCode(data));return operateDBlmp(680,rdb,handler);}
public int operateDB(int operate,UserAccess data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(UserAccess.EnCode(data));return operateDBlmp(681,rdb,handler);}
public int operateDB(int operate,UserAccount data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(UserAccount.EnCode(data));return operateDBlmp(682,rdb,handler);}
public int operateDB(int operate,UserInfo data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(UserInfo.EnCode(data));return operateDBlmp(683,rdb,handler);}
public int operateDB(int operate,UserPrivateInfo data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(UserPrivateInfo.EnCode(data));return operateDBlmp(684,rdb,handler);}
public int operateDB(int operate,WorkFlowPath data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(WorkFlowPath.EnCode(data));return operateDBlmp(685,rdb,handler);}
public int operateDB(int operate,WorkGroup data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(WorkGroup.EnCode(data));return operateDBlmp(686,rdb,handler);}
public int operateDB(int operate,WorkGroupUser data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(WorkGroupUser.EnCode(data));return operateDBlmp(687,rdb,handler);}
public int operateDB(int operate,WorkProductFlow data,AnswerHandler<MsgResult> handler) throws IOException {RequestOperateDBProto rdb = new RequestOperateDBProto();rdb.setData(WorkProductFlow.EnCode(data));return operateDBlmp(688,rdb,handler);}

//batch
public int batchOperateAccountBailDB(int operate,List<AccountBail> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((AccountBail oo)->{try {dataList.add(AccountBail.EnCode(oo));} catch (IOException ex) {log.info("AccountBail EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(563,rbod,handler);}
public int batchOperateAccountFareDB(int operate,List<AccountFare> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((AccountFare oo)->{try {dataList.add(AccountFare.EnCode(oo));} catch (IOException ex) {log.info("AccountFare EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(564,rbod,handler);}
public int batchOperateAccountIcodeDB(int operate,List<AccountIcode> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((AccountIcode oo)->{try {dataList.add(AccountIcode.EnCode(oo));} catch (IOException ex) {log.info("AccountIcode EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(565,rbod,handler);}
public int batchOperateAccountInfoDB(int operate,List<AccountInfo> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((AccountInfo oo)->{try {dataList.add(AccountInfo.EnCode(oo));} catch (IOException ex) {log.info("AccountInfo EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(566,rbod,handler);}
public int batchOperateAccountInvestDB(int operate,List<AccountInvest> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((AccountInvest oo)->{try {dataList.add(AccountInvest.EnCode(oo));} catch (IOException ex) {log.info("AccountInvest EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(567,rbod,handler);}
public int batchOperateAlterOrderDB(int operate,List<AlterOrder> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((AlterOrder oo)->{try {dataList.add(AlterOrder.EnCode(oo));} catch (IOException ex) {log.info("AlterOrder EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(568,rbod,handler);}
public int batchOperateBailTempDB(int operate,List<BailTemp> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((BailTemp oo)->{try {dataList.add(BailTemp.EnCode(oo));} catch (IOException ex) {log.info("BailTemp EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(569,rbod,handler);}
public int batchOperateBailTempObjDB(int operate,List<BailTempObj> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((BailTempObj oo)->{try {dataList.add(BailTempObj.EnCode(oo));} catch (IOException ex) {log.info("BailTempObj EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(570,rbod,handler);}
public int batchOperateCancelOrderDB(int operate,List<CancelOrder> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((CancelOrder oo)->{try {dataList.add(CancelOrder.EnCode(oo));} catch (IOException ex) {log.info("CancelOrder EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(571,rbod,handler);}
public int batchOperateClearingCurrencyRatesDB(int operate,List<ClearingCurrencyRates> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ClearingCurrencyRates oo)->{try {dataList.add(ClearingCurrencyRates.EnCode(oo));} catch (IOException ex) {log.info("ClearingCurrencyRates EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(572,rbod,handler);}
public int batchOperateClearingDayBookDB(int operate,List<ClearingDayBook> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ClearingDayBook oo)->{try {dataList.add(ClearingDayBook.EnCode(oo));} catch (IOException ex) {log.info("ClearingDayBook EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(573,rbod,handler);}
public int batchOperateClearingExRightDB(int operate,List<ClearingExRight> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ClearingExRight oo)->{try {dataList.add(ClearingExRight.EnCode(oo));} catch (IOException ex) {log.info("ClearingExRight EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(574,rbod,handler);}
public int batchOperateClearingPriceDB(int operate,List<ClearingPrice> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ClearingPrice oo)->{try {dataList.add(ClearingPrice.EnCode(oo));} catch (IOException ex) {log.info("ClearingPrice EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(575,rbod,handler);}
public int batchOperateClearingProtfolioposDB(int operate,List<ClearingProtfoliopos> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ClearingProtfoliopos oo)->{try {dataList.add(ClearingProtfoliopos.EnCode(oo));} catch (IOException ex) {log.info("ClearingProtfoliopos EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(576,rbod,handler);}
public int batchOperateFareTempDB(int operate,List<FareTemp> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((FareTemp oo)->{try {dataList.add(FareTemp.EnCode(oo));} catch (IOException ex) {log.info("FareTemp EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(577,rbod,handler);}
public int batchOperateFareTempeObjDB(int operate,List<FareTempeObj> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((FareTempeObj oo)->{try {dataList.add(FareTempeObj.EnCode(oo));} catch (IOException ex) {log.info("FareTempeObj EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(578,rbod,handler);}
public int batchOperateFundStateDB(int operate,List<FundState> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((FundState oo)->{try {dataList.add(FundState.EnCode(oo));} catch (IOException ex) {log.info("FundState EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(579,rbod,handler);}
public int batchOperateFundTransferDB(int operate,List<FundTransfer> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((FundTransfer oo)->{try {dataList.add(FundTransfer.EnCode(oo));} catch (IOException ex) {log.info("FundTransfer EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(580,rbod,handler);}
public int batchOperateIOPVAccountDB(int operate,List<IOPVAccount> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((IOPVAccount oo)->{try {dataList.add(IOPVAccount.EnCode(oo));} catch (IOException ex) {log.info("IOPVAccount EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(581,rbod,handler);}
public int batchOperateIOPVProductDB(int operate,List<IOPVProduct> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((IOPVProduct oo)->{try {dataList.add(IOPVProduct.EnCode(oo));} catch (IOException ex) {log.info("IOPVProduct EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(582,rbod,handler);}
public int batchOperateIOPVProductUnitDB(int operate,List<IOPVProductUnit> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((IOPVProductUnit oo)->{try {dataList.add(IOPVProductUnit.EnCode(oo));} catch (IOException ex) {log.info("IOPVProductUnit EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(583,rbod,handler);}
public int batchOperateLogLoginInfoDB(int operate,List<LogLoginInfo> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((LogLoginInfo oo)->{try {dataList.add(LogLoginInfo.EnCode(oo));} catch (IOException ex) {log.info("LogLoginInfo EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(584,rbod,handler);}
public int batchOperateNewOrderDB(int operate,List<NewOrder> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((NewOrder oo)->{try {dataList.add(NewOrder.EnCode(oo));} catch (IOException ex) {log.info("NewOrder EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(585,rbod,handler);}
public int batchOperateObjClassCodeDB(int operate,List<ObjClassCode> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjClassCode oo)->{try {dataList.add(ObjClassCode.EnCode(oo));} catch (IOException ex) {log.info("ObjClassCode EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(586,rbod,handler);}
public int batchOperateObjClassCodeAtrrDB(int operate,List<ObjClassCodeAtrr> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjClassCodeAtrr oo)->{try {dataList.add(ObjClassCodeAtrr.EnCode(oo));} catch (IOException ex) {log.info("ObjClassCodeAtrr EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(587,rbod,handler);}
public int batchOperateObjETFDB(int operate,List<ObjETF> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjETF oo)->{try {dataList.add(ObjETF.EnCode(oo));} catch (IOException ex) {log.info("ObjETF EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(588,rbod,handler);}
public int batchOperateObjETFListDB(int operate,List<ObjETFList> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjETFList oo)->{try {dataList.add(ObjETFList.EnCode(oo));} catch (IOException ex) {log.info("ObjETFList EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(589,rbod,handler);}
public int batchOperateObjExRightInfoDB(int operate,List<ObjExRightInfo> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjExRightInfo oo)->{try {dataList.add(ObjExRightInfo.EnCode(oo));} catch (IOException ex) {log.info("ObjExRightInfo EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(590,rbod,handler);}
public int batchOperateObjIndexDB(int operate,List<ObjIndex> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjIndex oo)->{try {dataList.add(ObjIndex.EnCode(oo));} catch (IOException ex) {log.info("ObjIndex EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(591,rbod,handler);}
public int batchOperateObjIndexListDB(int operate,List<ObjIndexList> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjIndexList oo)->{try {dataList.add(ObjIndexList.EnCode(oo));} catch (IOException ex) {log.info("ObjIndexList EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(592,rbod,handler);}
public int batchOperateObjInfoDB(int operate,List<ObjInfo> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjInfo oo)->{try {dataList.add(ObjInfo.EnCode(oo));} catch (IOException ex) {log.info("ObjInfo EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(593,rbod,handler);}
public int batchOperateObjNewStockDB(int operate,List<ObjNewStock> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjNewStock oo)->{try {dataList.add(ObjNewStock.EnCode(oo));} catch (IOException ex) {log.info("ObjNewStock EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(594,rbod,handler);}
public int batchOperateObjPriceTickDB(int operate,List<ObjPriceTick> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjPriceTick oo)->{try {dataList.add(ObjPriceTick.EnCode(oo));} catch (IOException ex) {log.info("ObjPriceTick EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(595,rbod,handler);}
public int batchOperateObjProtfolioDB(int operate,List<ObjProtfolio> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjProtfolio oo)->{try {dataList.add(ObjProtfolio.EnCode(oo));} catch (IOException ex) {log.info("ObjProtfolio EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(596,rbod,handler);}
public int batchOperateObjProtfolioListDB(int operate,List<ObjProtfolioList> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjProtfolioList oo)->{try {dataList.add(ObjProtfolioList.EnCode(oo));} catch (IOException ex) {log.info("ObjProtfolioList EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(597,rbod,handler);}
public int batchOperateObjStructuredFundBaseDB(int operate,List<ObjStructuredFundBase> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjStructuredFundBase oo)->{try {dataList.add(ObjStructuredFundBase.EnCode(oo));} catch (IOException ex) {log.info("ObjStructuredFundBase EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(598,rbod,handler);}
public int batchOperateObjStructuredFundPartDB(int operate,List<ObjStructuredFundPart> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjStructuredFundPart oo)->{try {dataList.add(ObjStructuredFundPart.EnCode(oo));} catch (IOException ex) {log.info("ObjStructuredFundPart EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(599,rbod,handler);}
public int batchOperateObjUnderlyingCodeDB(int operate,List<ObjUnderlyingCode> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ObjUnderlyingCode oo)->{try {dataList.add(ObjUnderlyingCode.EnCode(oo));} catch (IOException ex) {log.info("ObjUnderlyingCode EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(600,rbod,handler);}
public int batchOperateOrderExecuteProgressDB(int operate,List<OrderExecuteProgress> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((OrderExecuteProgress oo)->{try {dataList.add(OrderExecuteProgress.EnCode(oo));} catch (IOException ex) {log.info("OrderExecuteProgress EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(601,rbod,handler);}
public int batchOperatePosDetailDB(int operate,List<PosDetail> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((PosDetail oo)->{try {dataList.add(PosDetail.EnCode(oo));} catch (IOException ex) {log.info("PosDetail EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(602,rbod,handler);}
public int batchOperateProductAccountDB(int operate,List<ProductAccount> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ProductAccount oo)->{try {dataList.add(ProductAccount.EnCode(oo));} catch (IOException ex) {log.info("ProductAccount EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(603,rbod,handler);}
public int batchOperateProductInfoDB(int operate,List<ProductInfo> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ProductInfo oo)->{try {dataList.add(ProductInfo.EnCode(oo));} catch (IOException ex) {log.info("ProductInfo EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(604,rbod,handler);}
public int batchOperateProductUnitDB(int operate,List<ProductUnit> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((ProductUnit oo)->{try {dataList.add(ProductUnit.EnCode(oo));} catch (IOException ex) {log.info("ProductUnit EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(605,rbod,handler);}
public int batchOperateRiskCtrlAssetsDB(int operate,List<RiskCtrlAssets> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((RiskCtrlAssets oo)->{try {dataList.add(RiskCtrlAssets.EnCode(oo));} catch (IOException ex) {log.info("RiskCtrlAssets EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(606,rbod,handler);}
public int batchOperateRiskIndexDB(int operate,List<RiskIndex> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((RiskIndex oo)->{try {dataList.add(RiskIndex.EnCode(oo));} catch (IOException ex) {log.info("RiskIndex EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(607,rbod,handler);}
public int batchOperateRiskSetsDB(int operate,List<RiskSets> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((RiskSets oo)->{try {dataList.add(RiskSets.EnCode(oo));} catch (IOException ex) {log.info("RiskSets EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(608,rbod,handler);}
public int batchOperateSafeForbidLoginDB(int operate,List<SafeForbidLogin> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((SafeForbidLogin oo)->{try {dataList.add(SafeForbidLogin.EnCode(oo));} catch (IOException ex) {log.info("SafeForbidLogin EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(609,rbod,handler);}
public int batchOperateSafeOtherAccessDB(int operate,List<SafeOtherAccess> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((SafeOtherAccess oo)->{try {dataList.add(SafeOtherAccess.EnCode(oo));} catch (IOException ex) {log.info("SafeOtherAccess EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(610,rbod,handler);}
public int batchOperateTradeReportDetailDB(int operate,List<TradeReportDetail> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((TradeReportDetail oo)->{try {dataList.add(TradeReportDetail.EnCode(oo));} catch (IOException ex) {log.info("TradeReportDetail EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(611,rbod,handler);}
public int batchOperateTradesetBrokerDB(int operate,List<TradesetBroker> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((TradesetBroker oo)->{try {dataList.add(TradesetBroker.EnCode(oo));} catch (IOException ex) {log.info("TradesetBroker EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(612,rbod,handler);}
public int batchOperateTradesetCalendarDB(int operate,List<TradesetCalendar> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((TradesetCalendar oo)->{try {dataList.add(TradesetCalendar.EnCode(oo));} catch (IOException ex) {log.info("TradesetCalendar EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(613,rbod,handler);}
public int batchOperateTradesetExchangeLimitDB(int operate,List<TradesetExchangeLimit> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((TradesetExchangeLimit oo)->{try {dataList.add(TradesetExchangeLimit.EnCode(oo));} catch (IOException ex) {log.info("TradesetExchangeLimit EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(614,rbod,handler);}
public int batchOperateTradesetPipDB(int operate,List<TradesetPip> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((TradesetPip oo)->{try {dataList.add(TradesetPip.EnCode(oo));} catch (IOException ex) {log.info("TradesetPip EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(615,rbod,handler);}
public int batchOperateTradeSimOrderQueneDB(int operate,List<TradeSimOrderQuene> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((TradeSimOrderQuene oo)->{try {dataList.add(TradeSimOrderQuene.EnCode(oo));} catch (IOException ex) {log.info("TradeSimOrderQuene EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(616,rbod,handler);}
public int batchOperateUserAccessDB(int operate,List<UserAccess> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((UserAccess oo)->{try {dataList.add(UserAccess.EnCode(oo));} catch (IOException ex) {log.info("UserAccess EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(617,rbod,handler);}
public int batchOperateUserAccountDB(int operate,List<UserAccount> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((UserAccount oo)->{try {dataList.add(UserAccount.EnCode(oo));} catch (IOException ex) {log.info("UserAccount EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(618,rbod,handler);}
public int batchOperateUserInfoDB(int operate,List<UserInfo> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((UserInfo oo)->{try {dataList.add(UserInfo.EnCode(oo));} catch (IOException ex) {log.info("UserInfo EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(619,rbod,handler);}
public int batchOperateUserPrivateInfoDB(int operate,List<UserPrivateInfo> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((UserPrivateInfo oo)->{try {dataList.add(UserPrivateInfo.EnCode(oo));} catch (IOException ex) {log.info("UserPrivateInfo EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(620,rbod,handler);}
public int batchOperateWorkFlowPathDB(int operate,List<WorkFlowPath> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((WorkFlowPath oo)->{try {dataList.add(WorkFlowPath.EnCode(oo));} catch (IOException ex) {log.info("WorkFlowPath EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(621,rbod,handler);}
public int batchOperateWorkGroupDB(int operate,List<WorkGroup> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((WorkGroup oo)->{try {dataList.add(WorkGroup.EnCode(oo));} catch (IOException ex) {log.info("WorkGroup EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(622,rbod,handler);}
public int batchOperateWorkGroupUserDB(int operate,List<WorkGroupUser> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((WorkGroupUser oo)->{try {dataList.add(WorkGroupUser.EnCode(oo));} catch (IOException ex) {log.info("WorkGroupUser EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(623,rbod,handler);}
public int batchOperateWorkProductFlowDB(int operate,List<WorkProductFlow> databatch,AnswerHandler<MsgResult> handler) throws IOException {RequestBatchOperateDB rbod = new RequestBatchOperateDB();List<byte[]> dataList = new ArrayList(databatch.size());databatch.stream().forEach((WorkProductFlow oo)->{try {dataList.add(WorkProductFlow.EnCode(oo));} catch (IOException ex) {log.info("WorkProductFlow EnCode fail:"+ex);}});rbod.setDataList(dataList);return batchOperateDBlmp(624,rbod,handler);}

//查询
public int queryAccountBailList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<AccountBail>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<AccountBail> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(AccountBail.DeCode(posb));} catch (IOException ex) {log.info("queryAccountBailList-PageDataProto fail decode:" + ex);}});TableData<AccountBail> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryAccountBailList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(500, id, RequestPageData.EnCode(rpd));return id;}
public int queryAccountFareList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<AccountFare>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<AccountFare> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(AccountFare.DeCode(posb));} catch (IOException ex) {log.info("queryAccountFareList-PageDataProto fail decode:" + ex);}});TableData<AccountFare> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryAccountFareList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(501, id, RequestPageData.EnCode(rpd));return id;}
public int queryAccountIcodeList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<AccountIcode>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<AccountIcode> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(AccountIcode.DeCode(posb));} catch (IOException ex) {log.info("queryAccountIcodeList-PageDataProto fail decode:" + ex);}});TableData<AccountIcode> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryAccountIcodeList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(502, id, RequestPageData.EnCode(rpd));return id;}
public int queryAccountInfoList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<AccountInfo>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<AccountInfo> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(AccountInfo.DeCode(posb));} catch (IOException ex) {log.info("queryAccountInfoList-PageDataProto fail decode:" + ex);}});TableData<AccountInfo> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryAccountInfoList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(503, id, RequestPageData.EnCode(rpd));return id;}
public int queryAccountInvestList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<AccountInvest>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<AccountInvest> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(AccountInvest.DeCode(posb));} catch (IOException ex) {log.info("queryAccountInvestList-PageDataProto fail decode:" + ex);}});TableData<AccountInvest> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryAccountInvestList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(504, id, RequestPageData.EnCode(rpd));return id;}
public int queryAlterOrderList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<AlterOrder>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<AlterOrder> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(AlterOrder.DeCode(posb));} catch (IOException ex) {log.info("queryAlterOrderList-PageDataProto fail decode:" + ex);}});TableData<AlterOrder> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryAlterOrderList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(505, id, RequestPageData.EnCode(rpd));return id;}
public int queryBailTempList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<BailTemp>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<BailTemp> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(BailTemp.DeCode(posb));} catch (IOException ex) {log.info("queryBailTempList-PageDataProto fail decode:" + ex);}});TableData<BailTemp> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryBailTempList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(506, id, RequestPageData.EnCode(rpd));return id;}
public int queryBailTempObjList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<BailTempObj>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<BailTempObj> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(BailTempObj.DeCode(posb));} catch (IOException ex) {log.info("queryBailTempObjList-PageDataProto fail decode:" + ex);}});TableData<BailTempObj> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryBailTempObjList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(507, id, RequestPageData.EnCode(rpd));return id;}
public int queryCancelOrderList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<CancelOrder>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<CancelOrder> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(CancelOrder.DeCode(posb));} catch (IOException ex) {log.info("queryCancelOrderList-PageDataProto fail decode:" + ex);}});TableData<CancelOrder> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryCancelOrderList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(508, id, RequestPageData.EnCode(rpd));return id;}
public int queryClearingCurrencyRatesList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ClearingCurrencyRates>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ClearingCurrencyRates> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ClearingCurrencyRates.DeCode(posb));} catch (IOException ex) {log.info("queryClearingCurrencyRatesList-PageDataProto fail decode:" + ex);}});TableData<ClearingCurrencyRates> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryClearingCurrencyRatesList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(509, id, RequestPageData.EnCode(rpd));return id;}
public int queryClearingDayBookList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ClearingDayBook>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ClearingDayBook> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ClearingDayBook.DeCode(posb));} catch (IOException ex) {log.info("queryClearingDayBookList-PageDataProto fail decode:" + ex);}});TableData<ClearingDayBook> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryClearingDayBookList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(510, id, RequestPageData.EnCode(rpd));return id;}
public int queryClearingExRightList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ClearingExRight>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ClearingExRight> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ClearingExRight.DeCode(posb));} catch (IOException ex) {log.info("queryClearingExRightList-PageDataProto fail decode:" + ex);}});TableData<ClearingExRight> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryClearingExRightList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(511, id, RequestPageData.EnCode(rpd));return id;}
public int queryClearingPriceList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ClearingPrice>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ClearingPrice> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ClearingPrice.DeCode(posb));} catch (IOException ex) {log.info("queryClearingPriceList-PageDataProto fail decode:" + ex);}});TableData<ClearingPrice> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryClearingPriceList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(512, id, RequestPageData.EnCode(rpd));return id;}
public int queryClearingProtfolioposList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ClearingProtfoliopos>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ClearingProtfoliopos> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ClearingProtfoliopos.DeCode(posb));} catch (IOException ex) {log.info("queryClearingProtfolioposList-PageDataProto fail decode:" + ex);}});TableData<ClearingProtfoliopos> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryClearingProtfolioposList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(513, id, RequestPageData.EnCode(rpd));return id;}
public int queryFareTempList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<FareTemp>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<FareTemp> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(FareTemp.DeCode(posb));} catch (IOException ex) {log.info("queryFareTempList-PageDataProto fail decode:" + ex);}});TableData<FareTemp> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryFareTempList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(514, id, RequestPageData.EnCode(rpd));return id;}
public int queryFareTempeObjList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<FareTempeObj>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<FareTempeObj> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(FareTempeObj.DeCode(posb));} catch (IOException ex) {log.info("queryFareTempeObjList-PageDataProto fail decode:" + ex);}});TableData<FareTempeObj> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryFareTempeObjList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(515, id, RequestPageData.EnCode(rpd));return id;}
public int queryFundStateList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<FundState>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<FundState> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(FundState.DeCode(posb));} catch (IOException ex) {log.info("queryFundStateList-PageDataProto fail decode:" + ex);}});TableData<FundState> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryFundStateList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(516, id, RequestPageData.EnCode(rpd));return id;}
public int queryFundTransferList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<FundTransfer>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<FundTransfer> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(FundTransfer.DeCode(posb));} catch (IOException ex) {log.info("queryFundTransferList-PageDataProto fail decode:" + ex);}});TableData<FundTransfer> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryFundTransferList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(517, id, RequestPageData.EnCode(rpd));return id;}
public int queryIOPVAccountList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<IOPVAccount>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<IOPVAccount> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(IOPVAccount.DeCode(posb));} catch (IOException ex) {log.info("queryIOPVAccountList-PageDataProto fail decode:" + ex);}});TableData<IOPVAccount> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryIOPVAccountList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(518, id, RequestPageData.EnCode(rpd));return id;}
public int queryIOPVProductList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<IOPVProduct>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<IOPVProduct> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(IOPVProduct.DeCode(posb));} catch (IOException ex) {log.info("queryIOPVProductList-PageDataProto fail decode:" + ex);}});TableData<IOPVProduct> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryIOPVProductList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(519, id, RequestPageData.EnCode(rpd));return id;}
public int queryIOPVProductUnitList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<IOPVProductUnit>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<IOPVProductUnit> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(IOPVProductUnit.DeCode(posb));} catch (IOException ex) {log.info("queryIOPVProductUnitList-PageDataProto fail decode:" + ex);}});TableData<IOPVProductUnit> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryIOPVProductUnitList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(520, id, RequestPageData.EnCode(rpd));return id;}
public int queryLogLoginInfoList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<LogLoginInfo>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<LogLoginInfo> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(LogLoginInfo.DeCode(posb));} catch (IOException ex) {log.info("queryLogLoginInfoList-PageDataProto fail decode:" + ex);}});TableData<LogLoginInfo> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryLogLoginInfoList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(521, id, RequestPageData.EnCode(rpd));return id;}
public int queryNewOrderList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<NewOrder>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<NewOrder> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(NewOrder.DeCode(posb));} catch (IOException ex) {log.info("queryNewOrderList-PageDataProto fail decode:" + ex);}});TableData<NewOrder> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryNewOrderList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(522, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjClassCodeList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjClassCode>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjClassCode> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjClassCode.DeCode(posb));} catch (IOException ex) {log.info("queryObjClassCodeList-PageDataProto fail decode:" + ex);}});TableData<ObjClassCode> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjClassCodeList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(523, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjClassCodeAtrrList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjClassCodeAtrr>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjClassCodeAtrr> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjClassCodeAtrr.DeCode(posb));} catch (IOException ex) {log.info("queryObjClassCodeAtrrList-PageDataProto fail decode:" + ex);}});TableData<ObjClassCodeAtrr> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjClassCodeAtrrList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(524, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjETFList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjETF>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjETF> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjETF.DeCode(posb));} catch (IOException ex) {log.info("queryObjETFList-PageDataProto fail decode:" + ex);}});TableData<ObjETF> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjETFList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(525, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjETFListList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjETFList>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjETFList> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjETFList.DeCode(posb));} catch (IOException ex) {log.info("queryObjETFListList-PageDataProto fail decode:" + ex);}});TableData<ObjETFList> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjETFListList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(526, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjExRightInfoList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjExRightInfo>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjExRightInfo> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjExRightInfo.DeCode(posb));} catch (IOException ex) {log.info("queryObjExRightInfoList-PageDataProto fail decode:" + ex);}});TableData<ObjExRightInfo> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjExRightInfoList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(527, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjIndexList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjIndex>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjIndex> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjIndex.DeCode(posb));} catch (IOException ex) {log.info("queryObjIndexList-PageDataProto fail decode:" + ex);}});TableData<ObjIndex> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjIndexList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(528, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjIndexListList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjIndexList>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjIndexList> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjIndexList.DeCode(posb));} catch (IOException ex) {log.info("queryObjIndexListList-PageDataProto fail decode:" + ex);}});TableData<ObjIndexList> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjIndexListList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(529, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjInfoList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjInfo>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjInfo> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjInfo.DeCode(posb));} catch (IOException ex) {log.info("queryObjInfoList-PageDataProto fail decode:" + ex);}});TableData<ObjInfo> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjInfoList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(530, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjNewStockList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjNewStock>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjNewStock> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjNewStock.DeCode(posb));} catch (IOException ex) {log.info("queryObjNewStockList-PageDataProto fail decode:" + ex);}});TableData<ObjNewStock> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjNewStockList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(531, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjPriceTickList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjPriceTick>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjPriceTick> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjPriceTick.DeCode(posb));} catch (IOException ex) {log.info("queryObjPriceTickList-PageDataProto fail decode:" + ex);}});TableData<ObjPriceTick> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjPriceTickList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(532, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjProtfolioList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjProtfolio>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjProtfolio> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjProtfolio.DeCode(posb));} catch (IOException ex) {log.info("queryObjProtfolioList-PageDataProto fail decode:" + ex);}});TableData<ObjProtfolio> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjProtfolioList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(533, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjProtfolioListList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjProtfolioList>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjProtfolioList> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjProtfolioList.DeCode(posb));} catch (IOException ex) {log.info("queryObjProtfolioListList-PageDataProto fail decode:" + ex);}});TableData<ObjProtfolioList> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjProtfolioListList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(534, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjStructuredFundBaseList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjStructuredFundBase>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjStructuredFundBase> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjStructuredFundBase.DeCode(posb));} catch (IOException ex) {log.info("queryObjStructuredFundBaseList-PageDataProto fail decode:" + ex);}});TableData<ObjStructuredFundBase> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjStructuredFundBaseList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(535, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjStructuredFundPartList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjStructuredFundPart>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjStructuredFundPart> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjStructuredFundPart.DeCode(posb));} catch (IOException ex) {log.info("queryObjStructuredFundPartList-PageDataProto fail decode:" + ex);}});TableData<ObjStructuredFundPart> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjStructuredFundPartList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(536, id, RequestPageData.EnCode(rpd));return id;}
public int queryObjUnderlyingCodeList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ObjUnderlyingCode>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ObjUnderlyingCode> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ObjUnderlyingCode.DeCode(posb));} catch (IOException ex) {log.info("queryObjUnderlyingCodeList-PageDataProto fail decode:" + ex);}});TableData<ObjUnderlyingCode> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryObjUnderlyingCodeList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(537, id, RequestPageData.EnCode(rpd));return id;}
public int queryOrderExecuteProgressList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<OrderExecuteProgress>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<OrderExecuteProgress> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(OrderExecuteProgress.DeCode(posb));} catch (IOException ex) {log.info("queryOrderExecuteProgressList-PageDataProto fail decode:" + ex);}});TableData<OrderExecuteProgress> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryOrderExecuteProgressList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(538, id, RequestPageData.EnCode(rpd));return id;}
public int queryPosDetailList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<PosDetail>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<PosDetail> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(PosDetail.DeCode(posb));} catch (IOException ex) {log.info("queryPosDetailList-PageDataProto fail decode:" + ex);}});TableData<PosDetail> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryPosDetailList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(539, id, RequestPageData.EnCode(rpd));return id;}
public int queryProductAccountList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ProductAccount>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ProductAccount> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ProductAccount.DeCode(posb));} catch (IOException ex) {log.info("queryProductAccountList-PageDataProto fail decode:" + ex);}});TableData<ProductAccount> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryProductAccountList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(540, id, RequestPageData.EnCode(rpd));return id;}
public int queryProductInfoList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ProductInfo>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ProductInfo> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ProductInfo.DeCode(posb));} catch (IOException ex) {log.info("queryProductInfoList-PageDataProto fail decode:" + ex);}});TableData<ProductInfo> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryProductInfoList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(541, id, RequestPageData.EnCode(rpd));return id;}
public int queryProductUnitList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<ProductUnit>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<ProductUnit> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(ProductUnit.DeCode(posb));} catch (IOException ex) {log.info("queryProductUnitList-PageDataProto fail decode:" + ex);}});TableData<ProductUnit> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryProductUnitList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(542, id, RequestPageData.EnCode(rpd));return id;}
public int queryRiskCtrlAssetsList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<RiskCtrlAssets>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<RiskCtrlAssets> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(RiskCtrlAssets.DeCode(posb));} catch (IOException ex) {log.info("queryRiskCtrlAssetsList-PageDataProto fail decode:" + ex);}});TableData<RiskCtrlAssets> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryRiskCtrlAssetsList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(543, id, RequestPageData.EnCode(rpd));return id;}
public int queryRiskIndexList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<RiskIndex>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<RiskIndex> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(RiskIndex.DeCode(posb));} catch (IOException ex) {log.info("queryRiskIndexList-PageDataProto fail decode:" + ex);}});TableData<RiskIndex> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryRiskIndexList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(544, id, RequestPageData.EnCode(rpd));return id;}
public int queryRiskSetsList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<RiskSets>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<RiskSets> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(RiskSets.DeCode(posb));} catch (IOException ex) {log.info("queryRiskSetsList-PageDataProto fail decode:" + ex);}});TableData<RiskSets> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryRiskSetsList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(545, id, RequestPageData.EnCode(rpd));return id;}
public int querySafeForbidLoginList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<SafeForbidLogin>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<SafeForbidLogin> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(SafeForbidLogin.DeCode(posb));} catch (IOException ex) {log.info("querySafeForbidLoginList-PageDataProto fail decode:" + ex);}});TableData<SafeForbidLogin> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("querySafeForbidLoginList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(546, id, RequestPageData.EnCode(rpd));return id;}
public int querySafeOtherAccessList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<SafeOtherAccess>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<SafeOtherAccess> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(SafeOtherAccess.DeCode(posb));} catch (IOException ex) {log.info("querySafeOtherAccessList-PageDataProto fail decode:" + ex);}});TableData<SafeOtherAccess> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("querySafeOtherAccessList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(547, id, RequestPageData.EnCode(rpd));return id;}
public int queryTradeReportDetailList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<TradeReportDetail>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<TradeReportDetail> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(TradeReportDetail.DeCode(posb));} catch (IOException ex) {log.info("queryTradeReportDetailList-PageDataProto fail decode:" + ex);}});TableData<TradeReportDetail> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryTradeReportDetailList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(548, id, RequestPageData.EnCode(rpd));return id;}
public int queryTradesetBrokerList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<TradesetBroker>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<TradesetBroker> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(TradesetBroker.DeCode(posb));} catch (IOException ex) {log.info("queryTradesetBrokerList-PageDataProto fail decode:" + ex);}});TableData<TradesetBroker> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryTradesetBrokerList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(549, id, RequestPageData.EnCode(rpd));return id;}
public int queryTradesetCalendarList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<TradesetCalendar>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<TradesetCalendar> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(TradesetCalendar.DeCode(posb));} catch (IOException ex) {log.info("queryTradesetCalendarList-PageDataProto fail decode:" + ex);}});TableData<TradesetCalendar> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryTradesetCalendarList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(550, id, RequestPageData.EnCode(rpd));return id;}
public int queryTradesetExchangeLimitList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<TradesetExchangeLimit>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<TradesetExchangeLimit> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(TradesetExchangeLimit.DeCode(posb));} catch (IOException ex) {log.info("queryTradesetExchangeLimitList-PageDataProto fail decode:" + ex);}});TableData<TradesetExchangeLimit> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryTradesetExchangeLimitList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(551, id, RequestPageData.EnCode(rpd));return id;}
public int queryTradesetPipList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<TradesetPip>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<TradesetPip> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(TradesetPip.DeCode(posb));} catch (IOException ex) {log.info("queryTradesetPipList-PageDataProto fail decode:" + ex);}});TableData<TradesetPip> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryTradesetPipList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(552, id, RequestPageData.EnCode(rpd));return id;}
public int queryTradeSimOrderQueneList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<TradeSimOrderQuene>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<TradeSimOrderQuene> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(TradeSimOrderQuene.DeCode(posb));} catch (IOException ex) {log.info("queryTradeSimOrderQueneList-PageDataProto fail decode:" + ex);}});TableData<TradeSimOrderQuene> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryTradeSimOrderQueneList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(553, id, RequestPageData.EnCode(rpd));return id;}
public int queryUserAccessList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<UserAccess>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<UserAccess> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(UserAccess.DeCode(posb));} catch (IOException ex) {log.info("queryUserAccessList-PageDataProto fail decode:" + ex);}});TableData<UserAccess> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryUserAccessList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(554, id, RequestPageData.EnCode(rpd));return id;}
public int queryUserAccountList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<UserAccount>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<UserAccount> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(UserAccount.DeCode(posb));} catch (IOException ex) {log.info("queryUserAccountList-PageDataProto fail decode:" + ex);}});TableData<UserAccount> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryUserAccountList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(555, id, RequestPageData.EnCode(rpd));return id;}
public int queryUserInfoList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<UserInfo>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<UserInfo> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(UserInfo.DeCode(posb));} catch (IOException ex) {log.info("queryUserInfoList-PageDataProto fail decode:" + ex);}});TableData<UserInfo> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryUserInfoList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(556, id, RequestPageData.EnCode(rpd));return id;}
public int queryUserPrivateInfoList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<UserPrivateInfo>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<UserPrivateInfo> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(UserPrivateInfo.DeCode(posb));} catch (IOException ex) {log.info("queryUserPrivateInfoList-PageDataProto fail decode:" + ex);}});TableData<UserPrivateInfo> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryUserPrivateInfoList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(557, id, RequestPageData.EnCode(rpd));return id;}
public int queryWorkFlowPathList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<WorkFlowPath>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<WorkFlowPath> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(WorkFlowPath.DeCode(posb));} catch (IOException ex) {log.info("queryWorkFlowPathList-PageDataProto fail decode:" + ex);}});TableData<WorkFlowPath> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryWorkFlowPathList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(558, id, RequestPageData.EnCode(rpd));return id;}
public int queryWorkGroupList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<WorkGroup>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<WorkGroup> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(WorkGroup.DeCode(posb));} catch (IOException ex) {log.info("queryWorkGroupList-PageDataProto fail decode:" + ex);}});TableData<WorkGroup> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryWorkGroupList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(559, id, RequestPageData.EnCode(rpd));return id;}
public int queryWorkGroupUserList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<WorkGroupUser>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<WorkGroupUser> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(WorkGroupUser.DeCode(posb));} catch (IOException ex) {log.info("queryWorkGroupUserList-PageDataProto fail decode:" + ex);}});TableData<WorkGroupUser> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryWorkGroupUserList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(560, id, RequestPageData.EnCode(rpd));return id;}
public int queryWorkProductFlowList(int startIndex, List<TableCriteria> filteredColumns, List<String> sortedColumns, List<TableColumn.SortType> sortingOrders, int maxResult, AnswerHandler<TableData<WorkProductFlow>> handler) throws IOException {int id = getRequstID();RequestPageData rpd = TransferData.getRequestPageData(startIndex, filteredColumns, sortedColumns, sortingOrders, maxResult);AbstractWorker worker = new AbstractWorker() {@Override public void Onhandler(MsgEntity msg) {PageDataProto data;try {data = PageDataProto.DeCode(msg.getData());List<WorkProductFlow> datalist = new ArrayList<>(data.getMaxNum());data.getDataList().stream().forEach((byte[] posb) -> {try {datalist.add(WorkProductFlow.DeCode(posb));} catch (IOException ex) {log.info("queryWorkProductFlowList-PageDataProto fail decode:" + ex);}});TableData<WorkProductFlow> data0 = new TableData<>(datalist,data.isMoreRows(),data.getTotalRows());getAnswerHandler().OnAnswer(data0);} catch (IOException ex) {log.info("queryWorkProductFlowList fail decode:" + ex);}}};worker.setAnswerHandler(handler);this.sessionBucket.AcceptSession(id, worker);this.client.SendSYNCMsg(561, id, RequestPageData.EnCode(rpd));return id;}

}